<template>
  <div>
    <!-- <el-button @click="test">执行</el-button> -->
    <el-button @click="test1">构造函数</el-button>
  </div>
</template>
<script>
export default {
  data() {
    return {};
  },
  created() {},
  mounted() {},
  methods: {
    test() {
      class Person {
        // 构造函数，
        constructor(name, age) {
          this.name = name;
        }
        // 普通函数
        funStr() {
          console.log(`父类的方法`);
        }
      }
      class Son extends Person {
        constructor(name, age) {
          super(name, age); // 调用父类的构造函数
        }
        funStr() {
          console.log(`子类的方法`);
          super.funStr(); // 通过super直接调用父类的方法
        }
      }
      var son = new Son('刘天王', 22);
      son.funStr();
      // 1. 继承中，如果实例化子类输出一个方法，先看子类有没有这个方法，如果有就先执行子类的
      // 2. 继承中，如果子类里没有，就去找父类有没有这个方法，就执行父类的这个方法

      class P {
        constructor(x, y) {
          this.x = x;
          this.y = y;
        }
        sum() {
          console.log('sum:', this.x - this.y);
        }
      }
      class s1 extends P(x, y) {
        constructor(x, y) {
          ssuper(x, y);
          this.x = x;
          this.y = y;
        }
        subtreac5(x, y) {
          console.log('sum:', this.x - this.y);
        }
      }
    },
    // 构造函数继承
    test1() {
      /** js继承 */
      // 1 使用父构造函数
      function Father(name, age) {
        // this指向父构造函数
        this.name = name;
        this.age = age;
      }
      Father.prototype.money = function() {
        console.log('function money');
      };
      function Son(name, age, score) {
        // 通过call使Father的this指向Son
        Father.call(this, name, age);
        this.score = score;
      }
      Son.prototype = new Father();
      // 如果利用对象的形式修改了原型对象，要使用constructor 指回原来的构造函数
      Son.prototype.constrctor = Son;
      // 子类的方法
      Son.prototype.exam = function() {
        console.log('子类的专属方法');
      };

      var son = new Son('刘德华', 18);
      console.log('son:', son);
    }
  }
};
</script>
<style lang="scss" scoped></style>
